home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1992 / 09 / 2 / window-machine / wm_source.ampk / WM_Disk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-01  |  19.9 KB  |  1,116 lines
  1. #include <WM.h>
  2. #include <MyStructs.h>
  3.  
  4. USHORT SaveWin()
  5. {
  6.     while(helpW)
  7.     {
  8.         if(WriteWin(helpW)) return(1);
  9.         helpW=helpW->NextWindow;
  10.     }
  11.     return(0);
  12. }
  13. USHORT SaveData(UBYTE SArt)
  14. {
  15.     UBYTE Mo[1];
  16.     USHORT ERR;
  17.     Datei=NULL;
  18.     if(suffix==0)
  19.     {
  20.         suffix=1;
  21.         Change=0;
  22.     }
  23.     strcpy(LEER,"WM-DATEN speichern !");
  24.     if(SArt==1)
  25.     {
  26.         if(areq==NULL) strcpy(LEER,"WM-Window speichern !");
  27.         else
  28.         {
  29.             if(areq->Type==0)
  30.                 strcpy(LEER,"Requester speichern !");
  31.             if(areq->Type==1)
  32.                 strcpy(LEER,"AutoReq speichern !");
  33.             if(areq->Type==2)
  34.                 strcpy(LEER,"Alert speichern !");
  35.         }
  36.     }
  37.     ERR=FileRequester(LEER,78);
  38.     if(ERR > 1) return(2);
  39.     if(ERR==1)
  40.     {
  41.         Error(0,1,1);
  42.         return(2);
  43.     }
  44.     Work();
  45.     if(strlen(FileName) == 0) return(2);
  46.     if(    FileName[strlen(FileName)-3] != ZCode[6][0] &&
  47.         FileName[strlen(FileName)-2] != ZCode[6][1] &&
  48.         FileName[strlen(FileName)-1] != ZCode[6][2] )
  49.     {
  50.         strcat(FileName,ZCode[6]);
  51.         strcat(Fname,ZCode[6]);
  52.     }
  53.     if(!(Datei=Open(FileName,MODE_NEWFILE))) return(1);
  54.     if(write=Write(Datei,IDENT,sizeof(IDENT)) != sizeof(IDENT)) return(1);
  55.     if(SArt==1)
  56.     {
  57.         Mo[0]='3';
  58.         if(write=Write(Datei,Mo,sizeof(Mo)) != sizeof(Mo)) return(1);
  59.         helpW=awin->NextWindow;
  60.         FW=awin->Parent;
  61.         awin->NextWindow=NULL;
  62.         awin->Parent=NULL;
  63.         err=WriteWin(awin);
  64.         awin->NextWindow=helpW;
  65.         awin->Parent=FW;
  66.         if(err)    return(1);
  67.     }
  68.     if(noscW != NULL && SArt==0)
  69.     {
  70.         Mo[0]='1';
  71.         if(write=Write(Datei,Mo,sizeof(Mo)) != sizeof(Mo)) return(1);
  72.         helpW=noscW;
  73.         if(SaveWin()) return(1);
  74.     }
  75.     if(firstS != NULL && SArt==0)
  76.     {
  77.         Mo[0]='2';
  78.         if(write=Write(Datei,Mo,sizeof(Mo)) != sizeof(Mo)) return(1);
  79.         helpS=firstS;
  80.         while(helpS)
  81.         {
  82.             if(write=Write(Datei,helpS,
  83.                 sizeof(struct MyScreen)) !=
  84.                 sizeof(struct MyScreen)) return(1);
  85.             if(helpS->FirstWindow)
  86.             {
  87.                 helpW=helpS->FirstWindow;
  88.                 if(SaveWin()) return(1);
  89.             }
  90.             helpS=helpS->NextScreen;
  91.         }
  92.     }
  93.     Mo[0]='0';
  94.     if(write=Write(Datei,Mo,sizeof(Mo)) != sizeof(Mo)) return(1);
  95.     Change=0;
  96.     Ready();
  97.     return(0);
  98. }
  99. USHORT WriteWin(struct MyWindow *w)
  100. {
  101.     if(write=Write(Datei,w,sizeof(struct MyWindow)) !=
  102.         sizeof(struct MyWindow)) return(1);
  103.     if(WrText(w->FirstText)) return(1);
  104.     if(WrGadget(w->FirstGadget)) return(1);
  105.     actM=w->MenuStrip;
  106.     if(WrMenu()) return(1);
  107.     if(w->CheckMark)
  108.     {
  109.         if(WrImage(w->CheckMark)) return(1);
  110.     }
  111.     areq=w->FirstRequest;
  112.     if(areq)
  113.     {
  114.         if(write=Write(Datei,areq,sizeof(struct MyRequest)) !=
  115.             sizeof(struct MyRequest)) return(1);
  116.         if(WrBorder(areq->ReqBorder)) return(1);
  117.         if(areq->ReqImage)
  118.         {
  119.             if(WrImage(areq->ReqImage)) return(1);
  120.         }
  121.     }
  122.     
  123.     return(0);
  124. }
  125. USHORT WrText(struct MyText *text)
  126. {
  127.     wert=sizeof(struct MyText)-sizeof(struct IntuiText);
  128.     while(text)
  129.     {
  130.         if(write=Write(Datei,text,wert) != wert) return(1);
  131.         text=text->NextText;
  132.     }
  133.     return(0);
  134. }
  135. USHORT WrImage(struct MyImage *image)
  136. {
  137.     wert=sizeof(struct MyImage)-sizeof(struct Image);
  138.     if(write=Write(Datei,image,wert) != wert) return(1);
  139.     if(image->ImageData)
  140.     {
  141.         if(write=Write(Datei,image->ImageData,image->Size)
  142.             != image->Size) return(1);
  143.     }
  144.     return(0);
  145. }
  146. USHORT WrGadget(struct MyGadget *gadget)
  147. {
  148.     while(gadget)
  149.     {
  150.         wert=sizeof(struct MyGadget)-
  151.             (sizeof(struct Gadget)+sizeof(struct StringInfo));
  152.         if(write=Write(Datei,gadget,wert) != wert) return(1);
  153.         if(WrBorder(gadget->GadgetBorder)) return(1);
  154.         if(WrBorder(gadget->SelectBorder)) return(1);
  155.         if(gadget->GadgetImage)
  156.         {
  157.             if(WrImage(gadget->GadgetImage)) return(1);
  158.         }
  159.         if(gadget->SelectImage)
  160.         {
  161.             if(WrImage(gadget->SelectImage)) return(1);
  162.         }
  163.         if(gadget->PropImage) 
  164.         {
  165.             if(WrImage(gadget->PropImage)) return(1);
  166.         }
  167.         if(gadget->PSImage)
  168.         {
  169.             if(WrImage(gadget->PSImage)) return(1);
  170.         }
  171.         if(WrText(gadget->FirstText)) return(1);
  172.         if(gadget->Buffer)
  173.         {
  174.             if(write=Write(Datei,gadget->Buffer,gadget->MaxChars) !=
  175.                 gadget->MaxChars) return(1);
  176.         }
  177.         gadget=gadget->NextGadget;
  178.     }
  179.     return(0);
  180. }
  181. USHORT WrBorder(struct MyBorder *border)
  182. {
  183.     wert=sizeof(struct MyBorder)-sizeof(struct Border);
  184.     while(border)
  185.     {
  186.         if(write=Write(Datei,border,wert) != wert) return(1);
  187.         border=border->NextBorder;
  188.     }
  189.     return(0);
  190. }
  191. USHORT WrMenu()
  192. {
  193.     
  194.     while(actM)
  195.     {
  196.         wert=sizeof(struct MyMenu)-sizeof(struct Menu);
  197.         if(write=Write(Datei,actM,wert) != wert) return(1);
  198.         actI=actM->FirstItem;
  199.         if(WrItem()) return(1);
  200.         actM=actM->Next;
  201.     }
  202.     return(0);
  203. }
  204. USHORT WrItem()
  205. {
  206.     while(actI)
  207.     {
  208.         helpJ=actI;
  209.         if(WriteItem()) return(1);
  210.         actS=actI->Sub;
  211.         while(actS)
  212.         {
  213.             helpJ=actS;
  214.             if(WriteItem()) return(1);
  215.             actS=actS->Next;
  216.         }
  217.         actI=actI->Next;
  218.     }
  219.     return(0);
  220. }
  221. USHORT WriteItem()
  222. {
  223.     wert=sizeof(struct MyItem)-sizeof(struct MenuItem);
  224.     if(write=Write(Datei,helpJ,wert) != wert) return(1);
  225.     if(WrText(helpJ->ItemText)) return(1);
  226.     if(WrText(helpJ->SelectText)) return(1);
  227.     if(helpJ->ItemImage)
  228.     {
  229.         if(WrImage(helpJ->ItemImage)) return(1);
  230.     }
  231.     if(helpJ->SelectImage)
  232.     {
  233.         if(WrImage(helpJ->SelectImage)) return(1);
  234.     }
  235.     return(0);
  236. }
  237. VOID LoadWin()
  238. {
  239.     firstW=NULL;
  240.     lastW=NULL;
  241.     awin=(struct MyWindow *)1L;
  242.     while(awin)
  243.     {
  244.         ReadWin();
  245.         awin=awin->NextWindow;
  246.     }
  247.     awin=lastW;
  248. }
  249. USHORT LoadData(UBYTE LArt)
  250. {
  251.     UBYTE Mo[1];
  252.     USHORT ERR;
  253.     Datei=NULL;
  254.     if(suffix==0)
  255.     {
  256.         suffix=1;
  257.         Change=0;
  258.     }
  259.     strcpy(LEER,"WM-DATEN laden !");
  260.     if(LArt==1) strcpy(LEER,"WM-Window laden !");
  261.     ERR=FileRequester(LEER,90);
  262.     if(ERR > 1) return(2);
  263.     if(ERR==1)
  264.     {
  265.         Error(0,1,1);
  266.         return(2);
  267.     }
  268.     if(strlen(FileName) == 0) return(2);
  269.     Work();
  270.     if(    FileName[strlen(FileName)-3] != ZCode[6][0] &&
  271.         FileName[strlen(FileName)-2] != ZCode[6][1] &&
  272.         FileName[strlen(FileName)-1] != ZCode[6][2] ) return(3);
  273.     if(!(Datei=Open(FileName,MODE_OLDFILE))) return(1);
  274.     if(read=Read(Datei,LEER,sizeof(IDENT)) != sizeof(IDENT)) return(1);
  275.     if(strcmp(LEER,IDENT)) return(3);
  276.     Read(Datei,Mo,sizeof(Mo));
  277.     if(LArt==1 && (Mo[0] == '1' || Mo[0] == '2')) return(4);
  278.     if(LArt==0) ClearAll();
  279.     if(Mo[0]=='3' && LArt==1)
  280.     {
  281.         ReadWin();
  282.         if(asc)
  283.         {
  284.             if(asc->FirstWindow == NULL)
  285.                 asc->FirstWindow=awin;
  286.         }
  287.         else
  288.         {
  289.             if(awin==firstW) noscW=firstW;
  290.         }
  291.         Read(Datei,Mo,sizeof(Mo));
  292.     }
  293.     if(LArt==0 && (Mo[0] == '1' || Mo[0] == '3'))
  294.     {
  295.         asc=NULL;
  296.         LoadWin();
  297.         noscW=firstW;
  298.         Read(Datei,Mo,sizeof(Mo));
  299.     }
  300.     if(Mo[0]=='2' && LArt==0)
  301.     {
  302.         firstS=NULL;
  303.         lastS=NULL;
  304.         asc=(struct MyScreen *)1L;
  305.         while(asc)
  306.         {
  307.             asc=(struct MyScreen *)
  308.                 AllocMem(sizeof(struct MyScreen),
  309.                     MEMF_CLEAR|MEMF_PUBLIC);
  310.             Read(Datei,asc,sizeof(struct MyScreen));
  311.             if(firstS==NULL) firstS=asc;
  312.             else lastS->NextScreen=asc;
  313.             asc->Parent=lastS;
  314.             lastS=asc;
  315.             if(asc->FirstWindow) LoadWin();
  316.             asc->FirstWindow=firstW;
  317.             asc=asc->NextScreen;
  318.         }
  319.     }
  320.     Close(Datei);
  321.     Datei=NULL;
  322.     if(LArt==0) NewLoad();
  323.     else
  324.     {
  325.         awin->win=NULL;
  326.         awin->Screen=sc;
  327.         SetNewWin(1);
  328.         TestWok();
  329.     }
  330.     Ready();
  331.     return(0);
  332. }
  333.  
  334. VOID ReadWin()
  335. {
  336.     awin=(struct MyWindow *)
  337.         AllocMem(sizeof(struct MyWindow),
  338.             MEMF_CLEAR|MEMF_PUBLIC);
  339.     Read(Datei,awin,sizeof(struct MyWindow));
  340.     if(firstW==NULL) firstW=awin;
  341.     else lastW->NextWindow=awin;
  342.     awin->Parent=lastW;
  343.     awin->Wsc=asc;
  344.     lastW=awin;
  345.     if(awin->FirstText)
  346.     {
  347.         ReadText();
  348.         awin->FirstText=firstT;
  349.     }
  350.     if(awin->FirstGadget)
  351.     {
  352.         ReadGadget();
  353.         awin->FirstGadget=firstG;
  354.     }
  355.     if(awin->MenuStrip)
  356.     {
  357.         ReadMenu();
  358.         awin->MenuStrip=firstM;
  359.         MakeMenu();
  360.     }
  361.     if(awin->CheckMark)
  362.     {
  363.         ReadImage();
  364.         awin->CheckMark=helpI;
  365.     }
  366.     if(awin->FirstRequest)
  367.     {
  368.         ReadRequest();
  369.         awin->FirstRequest=areq;
  370.     }
  371. }
  372. VOID ReadRequest()
  373. {
  374.     areq=(struct MyRequest *)AllocMem(sizeof(struct MyRequest),
  375.         MEMF_CLEAR|MEMF_PUBLIC);
  376.     Read(Datei,areq,sizeof(struct MyRequest));
  377.     if(areq->ReqBorder)
  378.     {
  379.         BType=2;
  380.         firstGB=NULL;
  381.         lastGB=NULL;
  382.         ReadBorder();
  383.         areq->ReqBorder=firstGB;
  384.     }
  385.     if(areq->ReqImage)
  386.     {
  387.         ReadImage();
  388.         areq->ReqImage=helpI;
  389.     }
  390. }
  391. VOID ReadText()
  392. {
  393.     firstT=NULL;
  394.     lastT=NULL;
  395.     aText=(struct MyText *)1L;
  396.     while(aText)
  397.     {
  398.         aText=(struct MyText *)
  399.             AllocMem(sizeof(struct MyText),
  400.                 MEMF_CLEAR|MEMF_PUBLIC);
  401.         Read(Datei,aText,sizeof(struct MyText)-sizeof(struct IntuiText));
  402.         if(firstT==NULL) firstT=aText;
  403.         else lastT->NextText=aText;
  404.         aText->Parent=lastT;
  405.         lastT=aText;
  406.         aText=aText->NextText;
  407.     }
  408.     aText=lastT;
  409. }
  410. VOID ReadImage()
  411. {
  412.     helpI=(struct MyImage *)AllocMem(sizeof(struct MyImage),
  413.         MEMF_CLEAR|MEMF_PUBLIC);
  414.     Read(Datei,helpI,sizeof(struct MyImage)-sizeof(struct Image));
  415.     if(helpI->Size > 0)
  416.     {
  417.         helpI->ImageData=(USHORT*)AllocMem(helpI->Size+10,
  418.             MEMF_CLEAR|MEMF_CHIP);
  419.         Read(Datei,helpI->ImageData,helpI->Size);
  420.     }
  421.     MakeImage();
  422. }
  423. VOID ReadGadget()
  424. {
  425.     firstG=NULL;
  426.     lastG=NULL;
  427.     agad=(struct MyGadget *)1L;
  428.     while(agad)
  429.     {
  430.         agad=(struct MyGadget *)
  431.             AllocMem(sizeof(struct MyGadget),
  432.                 MEMF_CLEAR|MEMF_PUBLIC);
  433.         Read(Datei,agad,sizeof(struct MyGadget)-
  434.             (sizeof(struct Gadget)+sizeof(struct StringInfo)));
  435.         if(firstG==NULL) firstG=agad;
  436.         else lastG->NextGadget=agad;
  437.         agad->Parent=lastG;
  438.         if(agad->GadgetBorder)
  439.         {
  440.             BType=0;
  441.             firstGB=NULL;
  442.             lastGB=NULL;
  443.             ReadBorder();
  444.             agad->GadgetBorder=firstGB;
  445.         }
  446.         if(agad->SelectBorder)
  447.         {
  448.             BType=1;
  449.             firstSB=NULL;
  450.             lastSB=NULL;
  451.             ReadBorder();
  452.             agad->SelectBorder=firstSB;
  453.         }
  454.         if(agad->GadgetImage)
  455.         {
  456.             ReadImage();
  457.             agad->GadgetImage=helpI;
  458.         }
  459.         if(agad->SelectImage)
  460.         {
  461.             ReadImage();
  462.             agad->SelectImage=helpI;
  463.         }
  464.         if(agad->PropImage)
  465.         {
  466.             ReadImage();
  467.             agad->PropImage=helpI;
  468.         }
  469.         if(agad->PSImage)
  470.         {
  471.             ReadImage();
  472.             agad->PSImage=helpI;
  473.         }
  474.         if(agad->FirstText)
  475.         {
  476.             ReadText();
  477.             agad->FirstText=firstT;
  478.         }
  479.         if(agad->Buffer)
  480.         {
  481.             agad->Buffer=(UBYTE *)AllocMem(agad->MaxChars+1,
  482.                 MEMF_CLEAR|MEMF_PUBLIC);
  483.             Read(Datei,agad->Buffer,agad->MaxChars);
  484.         }
  485.         lastG=agad;
  486.         agad=agad->NextGadget;
  487.     }
  488.     TestGok();
  489. }
  490. VOID ReadBorder()
  491. {
  492.     abor=(struct MyBorder *)1L;
  493.     while(abor)
  494.     {
  495.         abor=(struct MyBorder *)
  496.             AllocMem(sizeof(struct MyBorder),
  497.                 MEMF_CLEAR|MEMF_PUBLIC);
  498.         Read(Datei,abor,sizeof(struct MyBorder)-sizeof(struct Border));
  499.         if(BType==1)
  500.         {
  501.             if(firstSB==NULL) firstSB=abor;
  502.             else lastSB->NextBorder=abor;
  503.             abor->Parent=lastSB;
  504.             lastSB=abor;
  505.         }
  506.         else
  507.         {
  508.             if(firstGB==NULL) firstGB=abor;
  509.             else lastGB->NextBorder=abor;
  510.             abor->Parent=lastGB;
  511.             lastGB=abor;
  512.         }
  513.         abor=abor->NextBorder;
  514.     }
  515. }
  516. VOID ReadMenu()
  517. {
  518.     firstM=NULL;
  519.     lastM=NULL;
  520.     amenu=(struct MyMenu *)1L;
  521.     while(amenu)
  522.     {
  523.         amenu=(struct MyMenu *)AllocMem(sizeof(struct MyMenu),
  524.             MEMF_CLEAR|MEMF_PUBLIC);
  525.         Read(Datei,amenu,sizeof(struct MyMenu)-sizeof(struct Menu));
  526.         if(firstM==NULL) firstM=amenu;
  527.         else lastM->Next=amenu;
  528.         amenu->Parent=lastM;
  529.         if(amenu->FirstItem)
  530.         {
  531.             ReadItem();
  532.             amenu->FirstItem=firstI;
  533.         }
  534.         lastM=amenu;
  535.         amenu=amenu->Next;
  536.     }
  537.     amenu=lastM;
  538. }
  539. VOID ReadItem()
  540. {
  541.     firstI=NULL;
  542.     lastI=NULL;
  543.     aitem=(struct MyItem *)1L;
  544.     while(aitem)
  545.     {
  546.         aitem=(struct MyItem *)AllocMem(sizeof(struct MyItem),
  547.             MEMF_CLEAR|MEMF_PUBLIC);
  548.         Read(Datei,aitem,sizeof(struct MyItem)-sizeof(struct MenuItem));
  549.         if(firstI==NULL) firstI=aitem;
  550.         else lastI->Next=aitem;
  551.         aitem->Parent=lastI;
  552.         if(aitem->ItemText)
  553.         {
  554.             ReadText();
  555.             aitem->ItemText=firstT;
  556.         }
  557.         if(aitem->SelectText)
  558.         {
  559.             ReadText();
  560.             aitem->SelectText=firstT;
  561.         }
  562.         if(aitem->ItemImage)
  563.         {
  564.             ReadImage();
  565.             aitem->ItemImage=helpI;
  566.         }
  567.         if(aitem->SelectImage)
  568.         {
  569.             ReadImage();
  570.             aitem->SelectImage=helpI;
  571.         }
  572.         if(aitem->Sub)
  573.         {
  574.             ReadSub();
  575.             aitem->Sub=Sfirst;
  576.         }
  577.         lastI=aitem;
  578.         aitem=aitem->Next;
  579.     }
  580.     aitem=lastI;
  581. }
  582. VOID ReadSub()
  583. {
  584.     Sfirst=NULL;
  585.     Slast=NULL;
  586.     asub=(struct MyItem *)1L;
  587.     while(asub)
  588.     {
  589.         asub=(struct MyItem *)AllocMem(sizeof(struct MyItem),
  590.             MEMF_CLEAR|MEMF_PUBLIC);
  591.         Read(Datei,asub,sizeof(struct MyItem)-sizeof(struct MenuItem));
  592.         if(Sfirst==NULL) Sfirst=asub;
  593.         else Slast->Next=asub;
  594.         asub->Parent=Slast;
  595.         if(asub->ItemText)
  596.         {
  597.             ReadText();
  598.             asub->ItemText=firstT;
  599.         }
  600.         if(asub->SelectText)
  601.         {
  602.             ReadText();
  603.             asub->SelectText=firstT;
  604.         }
  605.         if(asub->ItemImage)
  606.         {
  607.             ReadImage();
  608.             asub->ItemImage=helpI;
  609.         }
  610.         if(asub->SelectImage)
  611.         {
  612.             ReadImage();
  613.             asub->SelectImage=helpI;
  614.         }
  615.         Slast=asub;
  616.         asub=asub->Next;
  617.     }
  618.     asub=Slast;
  619. }
  620. USHORT NewLoad()
  621. {
  622.     Work();
  623.     if(noscW)
  624.     {
  625.         sc=WMsc;
  626.         OpenW(noscW);
  627.     }
  628.     if(firstS)
  629.     {
  630.         asc=firstS;
  631.         lastS=firstS;
  632.         while(asc)
  633.         {
  634.             if(!(asc->sc=(struct Screen*)NScreen())) return(1);
  635.             sc=asc->sc;
  636.             vp=&sc->ViewPort;
  637.             LoadRGB4(vp,&asc->ColorMap[0],asc->Colors);
  638.             if(asc->FirstWindow) OpenW(asc->FirstWindow);
  639.             lastS=asc;
  640.             asc=asc->NextScreen;
  641.         }
  642.         asc=lastS;
  643.         TestSok();
  644.     }
  645.     ScreenToFront(sc);
  646.     Ready();
  647.     return(0);
  648. }
  649. VOID OpenW(struct MyWindow *w)
  650. {
  651.     firstW=w;
  652.     awin=firstW;
  653.     while(awin)
  654.     {
  655.         awin->win=NULL;
  656.         awin->Screen=sc;
  657.         SetNewWin(1);
  658.         lastW=awin;
  659.         awin=awin->NextWindow;
  660.     }
  661.     awin=lastW;
  662.     TestWok();
  663. }
  664. USHORT FileRequester(STRPTR *st,SHORT xpo)
  665. {
  666.     USHORT quit=TRUE;
  667.     TestDevice();
  668.     d--;
  669.     Disk[d].NextGadget=&PfeilUpGad;
  670.     PDir.NextGadget=&Disk[0];
  671.     FWindow.Screen=WMsc;
  672.     if (!(Wwin = (struct Window *) OpenWindow(&FWindow)))
  673.         return(1);
  674.     Wrp = Wwin->RPort;
  675.     WinBorder(Wwin);
  676.     PrintIText(Wrp,&DText[5],0,0);
  677.     text(Wrp,3,st,xpo,185);
  678.     ScreenToFront(WMsc);
  679.     out=0;
  680.     SY=0;
  681.     if(Change || First) SetWertF();
  682.     else if(Change==0)
  683.     {
  684.         firstF=NULL;
  685.         SetDir();
  686.         ShowDir();
  687.     }
  688.     do
  689.     {
  690.         Wait(1L << Wwin->UserPort->mp_SigBit);
  691.         while(Wmsg=(struct IntuiMessage*)GetMsg(Wwin->UserPort))
  692.         {
  693.             HolMsg(Wmsg);
  694.         switch(class)
  695.         {
  696.             case MOUSEMOVE: SY=1;
  697.                     break;
  698.             case GADGETDOWN:
  699.             switch(Id)
  700.             {
  701.                 case 30: SY=2;
  702.                     break;
  703.                 case 31: SY=3;
  704.                     break;
  705.                 case 32: SY=1;
  706.                     break;
  707.             }
  708.             break;
  709.             case GADGETUP:
  710.         /* FileGadgets */
  711.         switch(Id)
  712.         {
  713.         case 1:
  714.         case 2:
  715.         case 3:
  716.         case 4:
  717.         case 5:
  718.         case 6:
  719.         case 7:
  720.         case 8:
  721.         case 9:
  722.         case 10: helpF=firstF;
  723.             if(helpF)
  724.             {
  725.                 for(i=0; i<Dnr; i++)
  726.                     helpF=helpF->Next;
  727.             }
  728.             i=1;
  729.             ok=1;
  730.             while(ok)
  731.             {
  732.                 if(i==Id || helpF==NULL)
  733.                 {
  734.                     ok=0;
  735.                     if(helpF) 
  736.                     {
  737.                         if(helpF->Color == 3)
  738.                         {
  739.                             if(Pfad[strlen(Pfad)-1] != 58)
  740.                             {
  741.                                 strcat(Pfad,"/");
  742.                             }
  743.                             strcat(Pfad,helpF->Name);
  744.                             ShowDir();
  745.                         }
  746.                         else
  747.                         {
  748.                             strcpy(Fname,helpF->Name);
  749.                         }
  750.                         RefreshGList(&PfadName,Wwin,NULL,2);
  751.                     }
  752.                 }
  753.                 else
  754.                 {
  755.                     helpF=helpF->Next;
  756.                     i++;
  757.                 }
  758.             }
  759.             break;
  760.         /* Drives */
  761.         case 11:
  762.         case 12:
  763.         case 13:
  764.         case 14:
  765.         case 15:
  766.         case 16:
  767.         case 17:
  768.         case 18: strcpy(PFADUNDO,Pfad);
  769.             strcpy(Pfad,Drives1[Id-11]);
  770.             ShowDir();
  771.             break;
  772.         /* O K */
  773.         case 19:
  774.         /* Filename */
  775.         case 24: if(strlen(Fname))
  776.             {
  777.                 strcpy(FileName,Pfad);
  778.                 if(FileName[strlen(FileName)-1] != ':')
  779.                     strcat(FileName,"/");
  780.                 strcat(FileName,Fname);
  781.             }
  782.             else out=2; 
  783.             quit=FALSE;
  784.             break;
  785.         /* EXIT */
  786.         case 0: out=2;
  787.             quit=FALSE;
  788.             break;
  789.         /* Pfadname */
  790.         case 23: if(strcmp(Pfad,PFADUNDO))
  791.                 ShowDir();
  792.             break;
  793.             break;
  794.         /* ParentDir */
  795.         case 25: if(Pfad[strlen(Pfad)-1] == ':') break;
  796.             Back();
  797.             ShowDir();
  798.             break;
  799.         } /*switch Id */
  800.     } /* switch class */
  801.     if(SY==1)
  802.     {
  803.         i=Dnr;
  804.         if(Anzahl > 9)
  805.         {
  806.             Dnr=((ReglerInfo.VertPot+1)*(Anzahl-9)/65535);
  807.             if(Dnr != i) SetDir();
  808.         }
  809.         SY=0;
  810.     }
  811.     if(SY > 1)
  812.     {
  813.         while(class != GADGETUP)
  814.         {
  815.             if(SY==2)
  816.             {
  817.                 if(Dnr)
  818.                 {
  819.                     Dnr--;
  820.                     SetWertF();
  821.                 }
  822.             }
  823.             if(SY==3)
  824.             {
  825.                 if((Dnr+9)<Anzahl)
  826.                 {
  827.                     Dnr++;
  828.                     SetWertF();
  829.                 }
  830.             }
  831.             GetMessage(Wwin);
  832.         }
  833.         SY=0;
  834.     }
  835.     } /* while */
  836.     } while(quit); /* do */
  837.     CloseWindow(Wwin);
  838.     ScreenToFront(sc);
  839.         return(out);
  840. }
  841.  
  842. VOID Back()
  843. {
  844.     for(i=strlen(Pfad);
  845.         Pfad[i-1]!=':' && Pfad[i-1]!='/';
  846.         i--);
  847.         Pfad[i]=0;
  848.     if(Pfad[--i]=='/') Pfad[i]=0;
  849. }
  850.  
  851. /*    Text auf Bildschirm schreiben    */
  852.  
  853. VOID text(struct RastPort *rast,UBYTE col,UBYTE *s,SHORT x,SHORT y)
  854. {
  855.     SetPen(rast,col,JAM1);
  856.     Move(rast,x,y);
  857.     Text(rast,s,strlen(s));
  858. }
  859.  
  860. VOID TestDevice()
  861. {
  862.     d=0;
  863.     Fertig=FALSE;
  864.     root=(struct RootNode *)DOSBase->dl_Root;
  865.     info=(struct DosInfo *)BADDR(root->rn_Info);
  866.     devinfo=(struct DeviceNode *)BADDR(info->di_DevInfo);
  867.     while(devinfo && Fertig==FALSE)
  868.     {
  869.         next=(struct DeviceNode *)BADDR(devinfo->dn_Next);
  870.         if(devinfo->dn_Type==DLT_DEVICE && devinfo->dn_Task)
  871.         {
  872.             zeiger=(char *)BADDR(devinfo->dn_Name);
  873.             wert=*zeiger++;
  874.             if(wert>10) wert=10;
  875.             strncpy(Dname,zeiger,wert);
  876.             Dname[wert]=0;
  877.             if(strlen(Dname)==3)
  878.             {
  879.                 strcpy(Drives1[d],Dname);
  880.                 strcat(Drives1[d],":");
  881.                 GText[d].FrontPen=1;
  882.                 GText[d].BackPen=0;
  883.                 GText[d].DrawMode=JAM1;
  884.                 GText[d].LeftEdge=10;
  885.                 GText[d].TopEdge=3;
  886.                 GText[d].ITextFont=NULL;
  887.                 GText[d].IText=Drives1[d];
  888.                 GText[d].NextText=NULL;
  889.                 Disk[d].NextGadget=&Disk[d+1];
  890.                 Disk[d].LeftEdge=20;
  891.                 Disk[d].TopEdge=10+(d*18);
  892.                 Disk[d].Width=48;
  893.                 Disk[d].Height=12;
  894.                 Disk[d].Activation=RELVERIFY;
  895.                 Disk[d].GadgetType=BOOLGADGET;
  896.                 Disk[d].GadgetRender=(APTR)&Bool;
  897.                 Disk[d].SelectRender=NULL;
  898.                 Disk[d].GadgetText=>ext[d];
  899.                 Disk[d].MutualExclude=NULL;
  900.                 Disk[d].SpecialInfo=NULL;
  901.                 Disk[d].GadgetID=d+11;
  902.                 Disk[d].UserData=NULL;
  903.                 Disk[d].Flags=NULL;
  904.                 if(d++ == 8) Fertig=TRUE;
  905.             }
  906.         }
  907.         devinfo=next;
  908.     }
  909. }
  910. USHORT ReadDir()
  911. {
  912.     struct direntry *neu;
  913.     if(!(Eintrag=(struct FileInfoBlock *)
  914.         AllocMem(sizeof(struct FileInfoBlock),
  915.                 MEMF_PUBLIC|MEMF_CLEAR))) return(1);
  916.     if(!(dir=Lock(Pfad,ACCESS_READ))) return(2);
  917.     if(!Examine(dir,Eintrag)) return(2);
  918.     if(Eintrag->fib_DirEntryType < 0) return(11);
  919.     FreeFiles();
  920.     Anzahl=0;
  921.     firstD=NULL;
  922.     Dact=NULL;
  923.     while(ExNext(dir,Eintrag))
  924.     {
  925.         if(Eintrag->fib_DirEntryType>0) /* Dir */
  926.         {
  927.             neu=(struct direntry*)
  928.                 AllocMem(sizeof(struct direntry),
  929.                     MEMF_CLEAR|MEMF_PUBLIC);
  930.             neu->Next=NULL;
  931.             neu->Parent=NULL;
  932.             strcpy(neu->Name,Eintrag->fib_FileName);
  933.             neu->Color=3;
  934.             if(firstD==NULL)
  935.             {
  936.                 firstD=neu;
  937.                 Dact=firstD;
  938.             }
  939.             else Sortier(neu,1);
  940.             Anzahl++;
  941.         }
  942.         else /* Kein Directory, File */
  943.         {
  944.             i=1;
  945.             if(suffix)
  946.             {
  947.                 if(Eintrag->fib_FileName[strlen(Eintrag->fib_FileName)-3] == '.' &&
  948.                 Eintrag->fib_FileName[strlen(Eintrag->fib_FileName)-2] == 'w' &&
  949.                 Eintrag->fib_FileName[strlen(Eintrag->fib_FileName)-1] == 'm' ) i=1;
  950.                 else i=0;
  951.             }
  952.             if(i)
  953.             {
  954.                 neu=(struct direntry*)
  955.                     AllocMem(sizeof(struct direntry),
  956.                         MEMF_CLEAR|MEMF_PUBLIC);
  957.                 neu->Next=NULL;
  958.                 neu->Parent=NULL;
  959.                 neu->Color=1;
  960.                 strcpy(neu->Name,Eintrag->fib_FileName);
  961.                 if(firstF==NULL) firstF=neu;
  962.                 else Sortier(neu,0);
  963.                 Anzahl++;
  964.             }
  965.         }
  966.     }
  967.     if(Anzahl) Anzahl--;
  968.     if(IoErr() != ERROR_NO_MORE_ENTRIES) return(2);
  969.     if(Dact)
  970.     {
  971.         Dact->Next=firstF;
  972.         if(firstF) firstF->Parent=Dact;
  973.         firstF=firstD;
  974.         First=0;
  975.     }
  976.     Change=1;
  977.     Dnr=0;
  978.     SetWertF();
  979.     return(0);
  980. }
  981. VOID Sortier(struct direntry *f,UBYTE mode)
  982. {
  983.     UBYTE help1[80],help2[80];
  984.     ok=FALSE;
  985.     helpF=firstF;
  986.     if(mode) helpF=firstD;
  987.     while(ok==FALSE)
  988.     {
  989.         Umlaut(helpF->Name,help1);
  990.         Umlaut(f->Name,help2);
  991.         if(strcmp(help1,help2) > 0)
  992.         {
  993.             if(mode)
  994.             {
  995.                 if(helpF==firstD) firstD=f;
  996.             }
  997.             else
  998.             {
  999.                 if(helpF==firstF) firstF=f;
  1000.             }
  1001.             if(helpF->Next)
  1002.             {
  1003.                 f->Next=helpF;
  1004.                 f->Parent=helpF->Parent;
  1005.                 helpF->Parent->Next=f;
  1006.                 helpF->Parent=f;
  1007.             }
  1008.             else
  1009.             {
  1010.                 if(mode) Dact=helpF;
  1011.                 f->Next=helpF;
  1012.                 f->Parent=helpF->Parent;
  1013.                 helpF->Parent->Next=f;
  1014.                 helpF->Parent=f;
  1015.             }
  1016.             ok=TRUE;
  1017.         }
  1018.         else
  1019.         {
  1020.             if(helpF->Next) helpF=helpF->Next;
  1021.             else
  1022.             {
  1023.                 if(mode) Dact=f;
  1024.                 helpF->Next=f;
  1025.                 f->Parent=helpF;
  1026.                 ok=TRUE;
  1027.             }
  1028.         }
  1029.     }
  1030. }
  1031.  
  1032. /*    Umlaute eines Eintrags zerlegen (ä wird ae)    */
  1033.  
  1034. VOID Umlaut(UBYTE *s,UBYTE *t)
  1035. {
  1036.     while(*s != '\0')
  1037.     {
  1038.         if(*s == 'ä' || *s == 'Ä')
  1039.         {
  1040.             *t='a';
  1041.             t++;
  1042.             *t='e';
  1043.         }
  1044.         else if(*s == 'ö' || *s == 'Ö')
  1045.         {
  1046.             *t='o';
  1047.             t++;
  1048.             *t='e';
  1049.         }
  1050.         else if(*s == 'ü' || *s == 'Ü')
  1051.         {
  1052.             *t='u';
  1053.             t++;
  1054.             *t='e';
  1055.         }
  1056.         else if(*s == 'ß')
  1057.         {
  1058.             *t='s';
  1059.             t++;
  1060.             *t='s';
  1061.         }
  1062.         else *t=*s|32;
  1063.         s++;
  1064.         t++;
  1065.     }
  1066.     *t='\0';
  1067. }        
  1068.  
  1069. VOID SetDir()
  1070. {
  1071.     helpF=firstF;
  1072.     for(i=0; i<Dnr; i++) helpF=helpF->Next;
  1073.     SetDrMd(Wrp,JAM2);
  1074.     SetBPen(Wrp,2);
  1075.     for(i=0; i<10; i++)
  1076.     {
  1077.         LEER[0]=0;
  1078.         Move(Wrp,109,26+(i*8));
  1079.         if(helpF)
  1080.         {
  1081.             SetAPen(Wrp,helpF->Color);
  1082.             strncpy(LEER,helpF->Name,24);
  1083.             helpF=helpF->Next;
  1084.         }
  1085.         for(j=strlen(LEER); j<24; j++)
  1086.             strcat(LEER," ");
  1087.         Text(Wrp,LEER,24);
  1088.     }
  1089. }
  1090.  
  1091. VOID SetWertF()
  1092. {
  1093.     SetDir();
  1094.     SetWert(Dnr,Anzahl,Wwin,&Regler,&ReglerInfo);
  1095. }
  1096. VOID ShowDir()
  1097. {
  1098.     SetPointer(Wwin,Wecker,20,15,0,0);
  1099.     err=ReadDir();
  1100.     if(Eintrag) FreeMem(Eintrag,sizeof(struct FileInfoBlock));
  1101.     if(dir) UnLock(dir);
  1102.     ClearPointer(Wwin);
  1103.     if(err) Error(err-1,0,1);
  1104.     if(err==11) Back();
  1105.     RefreshGList(&PfadName,Wwin,NULL,1);
  1106. }
  1107. VOID FreeFiles()
  1108. {
  1109.     while(firstF)
  1110.     {
  1111.         helpF=firstF->Next;
  1112.         FreeMem(firstF,sizeof(struct direntry));
  1113.         firstF=helpF;
  1114.     }
  1115. }
  1116.